// Generated from antlr/gdx.g4 by ANTLR 4.9.0-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { gdxListener } from "./gdxListener";
import { gdxVisitor } from "./gdxVisitor";


export class gdxParser extends Parser {
	public static readonly T__0 = 1;
	public static readonly T__1 = 2;
	public static readonly T__2 = 3;
	public static readonly T__3 = 4;
	public static readonly T__4 = 5;
	public static readonly T__5 = 6;
	public static readonly T__6 = 7;
	public static readonly T__7 = 8;
	public static readonly T__8 = 9;
	public static readonly T__9 = 10;
	public static readonly T__10 = 11;
	public static readonly T__11 = 12;
	public static readonly T__12 = 13;
	public static readonly T__13 = 14;
	public static readonly T__14 = 15;
	public static readonly INT = 16;
	public static readonly DIGIT = 17;
	public static readonly ID = 18;
	public static readonly NameChar = 19;
	public static readonly NameStartChar = 20;
	public static readonly STRING_ = 21;
	public static readonly HEX = 22;
	public static readonly HEXNUM = 23;
	public static readonly BIN = 24;
	public static readonly BINNUM = 25;
	public static readonly FLOAT_ = 26;
	public static readonly SIGN = 27;
	public static readonly WS = 28;
	public static readonly RULE_file = 0;
	public static readonly RULE_node = 1;
	public static readonly RULE_openBlock = 2;
	public static readonly RULE_block = 3;
	public static readonly RULE_endBlock = 4;
	public static readonly RULE_attr = 5;
	public static readonly RULE_instance = 6;
	public static readonly RULE_dictionary = 7;
	public static readonly RULE_pair = 8;
	public static readonly RULE_array = 9;
	public static readonly RULE_value = 10;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"file", "node", "openBlock", "block", "endBlock", "attr", "instance", 
		"dictionary", "pair", "array", "value",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, "'<'", "'>'", "'</'", "'='", "'('", "','", "')'", "'{'", "'}'", 
		"':'", "'['", "']'", "'true'", "'false'", "'null'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, "INT", "DIGIT", "ID", "NameChar", "NameStartChar", 
		"STRING_", "HEX", "HEXNUM", "BIN", "BINNUM", "FLOAT_", "SIGN", "WS",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(gdxParser._LITERAL_NAMES, gdxParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return gdxParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "gdx.g4"; }

	// @Override
	public get ruleNames(): string[] { return gdxParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return gdxParser._serializedATN; }

	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
		return new FailedPredicateException(this, predicate, message);
	}

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(gdxParser._ATN, this);
	}
	// @RuleVersion(0)
	public file(): FileContext {
		let _localctx: FileContext = new FileContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, gdxParser.RULE_file);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 23;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 22;
				this.node();
				}
				}
				this.state = 25;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === gdxParser.T__0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public node(): NodeContext {
		let _localctx: NodeContext = new NodeContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, gdxParser.RULE_node);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 27;
			this.openBlock();
			this.state = 31;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << gdxParser.T__0) | (1 << gdxParser.T__7) | (1 << gdxParser.T__10) | (1 << gdxParser.T__12) | (1 << gdxParser.T__13) | (1 << gdxParser.T__14) | (1 << gdxParser.INT) | (1 << gdxParser.ID) | (1 << gdxParser.STRING_) | (1 << gdxParser.FLOAT_))) !== 0)) {
				{
				{
				this.state = 28;
				this.block();
				}
				}
				this.state = 33;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 34;
			this.endBlock();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public openBlock(): OpenBlockContext {
		let _localctx: OpenBlockContext = new OpenBlockContext(this._ctx, this.state);
		this.enterRule(_localctx, 4, gdxParser.RULE_openBlock);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 36;
			this.match(gdxParser.T__0);
			this.state = 37;
			this.match(gdxParser.ID);
			this.state = 41;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === gdxParser.ID) {
				{
				{
				this.state = 38;
				this.attr();
				}
				}
				this.state = 43;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 44;
			this.match(gdxParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public block(): BlockContext {
		let _localctx: BlockContext = new BlockContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, gdxParser.RULE_block);
		try {
			this.state = 48;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case gdxParser.T__0:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 46;
				this.node();
				}
				break;
			case gdxParser.T__7:
			case gdxParser.T__10:
			case gdxParser.T__12:
			case gdxParser.T__13:
			case gdxParser.T__14:
			case gdxParser.INT:
			case gdxParser.ID:
			case gdxParser.STRING_:
			case gdxParser.FLOAT_:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 47;
				this.value();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public endBlock(): EndBlockContext {
		let _localctx: EndBlockContext = new EndBlockContext(this._ctx, this.state);
		this.enterRule(_localctx, 8, gdxParser.RULE_endBlock);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 50;
			this.match(gdxParser.T__2);
			this.state = 51;
			this.match(gdxParser.ID);
			this.state = 52;
			this.match(gdxParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public attr(): AttrContext {
		let _localctx: AttrContext = new AttrContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, gdxParser.RULE_attr);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 54;
			this.match(gdxParser.ID);
			this.state = 55;
			this.match(gdxParser.T__3);
			this.state = 56;
			this.match(gdxParser.STRING_);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public instance(): InstanceContext {
		let _localctx: InstanceContext = new InstanceContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, gdxParser.RULE_instance);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 58;
			this.match(gdxParser.ID);
			this.state = 59;
			this.match(gdxParser.T__4);
			this.state = 60;
			this.value();
			this.state = 65;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === gdxParser.T__5) {
				{
				{
				this.state = 61;
				this.match(gdxParser.T__5);
				this.state = 62;
				this.value();
				}
				}
				this.state = 67;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 68;
			this.match(gdxParser.T__6);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dictionary(): DictionaryContext {
		let _localctx: DictionaryContext = new DictionaryContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, gdxParser.RULE_dictionary);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 70;
			this.match(gdxParser.T__7);
			this.state = 71;
			this.pair();
			this.state = 76;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === gdxParser.T__5) {
				{
				{
				this.state = 72;
				this.match(gdxParser.T__5);
				this.state = 73;
				this.pair();
				}
				}
				this.state = 78;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 79;
			this.match(gdxParser.T__8);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public pair(): PairContext {
		let _localctx: PairContext = new PairContext(this._ctx, this.state);
		this.enterRule(_localctx, 16, gdxParser.RULE_pair);
		try {
			this.state = 87;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case gdxParser.STRING_:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 81;
				this.match(gdxParser.STRING_);
				this.state = 82;
				this.match(gdxParser.T__9);
				this.state = 83;
				this.value();
				}
				break;
			case gdxParser.ID:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 84;
				this.match(gdxParser.ID);
				this.state = 85;
				this.match(gdxParser.T__9);
				this.state = 86;
				this.value();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public array(): ArrayContext {
		let _localctx: ArrayContext = new ArrayContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, gdxParser.RULE_array);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 89;
			this.match(gdxParser.T__10);
			this.state = 90;
			this.value();
			this.state = 97;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === gdxParser.T__5) {
				{
				{
				this.state = 91;
				this.match(gdxParser.T__5);
				this.state = 93;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << gdxParser.T__7) | (1 << gdxParser.T__10) | (1 << gdxParser.T__12) | (1 << gdxParser.T__13) | (1 << gdxParser.T__14) | (1 << gdxParser.INT) | (1 << gdxParser.ID) | (1 << gdxParser.STRING_) | (1 << gdxParser.FLOAT_))) !== 0)) {
					{
					this.state = 92;
					this.value();
					}
				}

				}
				}
				this.state = 99;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 100;
			this.match(gdxParser.T__11);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public value(): ValueContext {
		let _localctx: ValueContext = new ValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 20, gdxParser.RULE_value);
		try {
			this.state = 111;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case gdxParser.INT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 102;
				this.match(gdxParser.INT);
				}
				break;
			case gdxParser.FLOAT_:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 103;
				this.match(gdxParser.FLOAT_);
				}
				break;
			case gdxParser.STRING_:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 104;
				this.match(gdxParser.STRING_);
				}
				break;
			case gdxParser.T__7:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 105;
				this.dictionary();
				}
				break;
			case gdxParser.T__10:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 106;
				this.array();
				}
				break;
			case gdxParser.ID:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 107;
				this.instance();
				}
				break;
			case gdxParser.T__12:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 108;
				this.match(gdxParser.T__12);
				}
				break;
			case gdxParser.T__13:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 109;
				this.match(gdxParser.T__13);
				}
				break;
			case gdxParser.T__14:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 110;
				this.match(gdxParser.T__14);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public static readonly _serializedATN: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x1Et\x04\x02" +
		"\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
		"\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x03\x02\x06\x02" +
		"\x1A\n\x02\r\x02\x0E\x02\x1B\x03\x03\x03\x03\x07\x03 \n\x03\f\x03\x0E" +
		"\x03#\v\x03\x03\x03\x03\x03\x03\x04\x03\x04\x03\x04\x07\x04*\n\x04\f\x04" +
		"\x0E\x04-\v\x04\x03\x04\x03\x04\x03\x05\x03\x05\x05\x053\n\x05\x03\x06" +
		"\x03\x06\x03\x06\x03\x06\x03\x07\x03\x07\x03\x07\x03\x07\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x07\bB\n\b\f\b\x0E\bE\v\b\x03\b\x03\b\x03\t\x03\t\x03\t" +
		"\x03\t\x07\tM\n\t\f\t\x0E\tP\v\t\x03\t\x03\t\x03\n\x03\n\x03\n\x03\n\x03" +
		"\n\x03\n\x05\nZ\n\n\x03\v\x03\v\x03\v\x03\v\x05\v`\n\v\x07\vb\n\v\f\v" +
		"\x0E\ve\v\v\x03\v\x03\v\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03" +
		"\f\x03\f\x05\fr\n\f\x03\f\x02\x02\x02\r\x02\x02\x04\x02\x06\x02\b\x02" +
		"\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x02\x02\x02y\x02" +
		"\x19\x03\x02\x02\x02\x04\x1D\x03\x02\x02\x02\x06&\x03\x02\x02\x02\b2\x03" +
		"\x02\x02\x02\n4\x03\x02\x02\x02\f8\x03\x02\x02\x02\x0E<\x03\x02\x02\x02" +
		"\x10H\x03\x02\x02\x02\x12Y\x03\x02\x02\x02\x14[\x03\x02\x02\x02\x16q\x03" +
		"\x02\x02\x02\x18\x1A\x05\x04\x03\x02\x19\x18\x03\x02\x02\x02\x1A\x1B\x03" +
		"\x02\x02\x02\x1B\x19\x03\x02\x02\x02\x1B\x1C\x03\x02\x02\x02\x1C\x03\x03" +
		"\x02\x02\x02\x1D!\x05\x06\x04\x02\x1E \x05\b\x05\x02\x1F\x1E\x03\x02\x02" +
		"\x02 #\x03\x02\x02\x02!\x1F\x03\x02\x02\x02!\"\x03\x02\x02\x02\"$\x03" +
		"\x02\x02\x02#!\x03\x02\x02\x02$%\x05\n\x06\x02%\x05\x03\x02\x02\x02&\'" +
		"\x07\x03\x02\x02\'+\x07\x14\x02\x02(*\x05\f\x07\x02)(\x03\x02\x02\x02" +
		"*-\x03\x02\x02\x02+)\x03\x02\x02\x02+,\x03\x02\x02\x02,.\x03\x02\x02\x02" +
		"-+\x03\x02\x02\x02./\x07\x04\x02\x02/\x07\x03\x02\x02\x0203\x05\x04\x03" +
		"\x0213\x05\x16\f\x0220\x03\x02\x02\x0221\x03\x02\x02\x023\t\x03\x02\x02" +
		"\x0245\x07\x05\x02\x0256\x07\x14\x02\x0267\x07\x04\x02\x027\v\x03\x02" +
		"\x02\x0289\x07\x14\x02\x029:\x07\x06\x02\x02:;\x07\x17\x02\x02;\r\x03" +
		"\x02\x02\x02<=\x07\x14\x02\x02=>\x07\x07\x02\x02>C\x05\x16\f\x02?@\x07" +
		"\b\x02\x02@B\x05\x16\f\x02A?\x03\x02\x02\x02BE\x03\x02\x02\x02CA\x03\x02" +
		"\x02\x02CD\x03\x02\x02\x02DF\x03\x02\x02\x02EC\x03\x02\x02\x02FG\x07\t" +
		"\x02\x02G\x0F\x03\x02\x02\x02HI\x07\n\x02\x02IN\x05\x12\n\x02JK\x07\b" +
		"\x02\x02KM\x05\x12\n\x02LJ\x03\x02\x02\x02MP\x03\x02\x02\x02NL\x03\x02" +
		"\x02\x02NO\x03\x02\x02\x02OQ\x03\x02\x02\x02PN\x03\x02\x02\x02QR\x07\v" +
		"\x02\x02R\x11\x03\x02\x02\x02ST\x07\x17\x02\x02TU\x07\f\x02\x02UZ\x05" +
		"\x16\f\x02VW\x07\x14\x02\x02WX\x07\f\x02\x02XZ\x05\x16\f\x02YS\x03\x02" +
		"\x02\x02YV\x03\x02\x02\x02Z\x13\x03\x02\x02\x02[\\\x07\r\x02\x02\\c\x05" +
		"\x16\f\x02]_\x07\b\x02\x02^`\x05\x16\f\x02_^\x03\x02\x02\x02_`\x03\x02" +
		"\x02\x02`b\x03\x02\x02\x02a]\x03\x02\x02\x02be\x03\x02\x02\x02ca\x03\x02" +
		"\x02\x02cd\x03\x02\x02\x02df\x03\x02\x02\x02ec\x03\x02\x02\x02fg\x07\x0E" +
		"\x02\x02g\x15\x03\x02\x02\x02hr\x07\x12\x02\x02ir\x07\x1C\x02\x02jr\x07" +
		"\x17\x02\x02kr\x05\x10\t\x02lr\x05\x14\v\x02mr\x05\x0E\b\x02nr\x07\x0F" +
		"\x02\x02or\x07\x10\x02\x02pr\x07\x11\x02\x02qh\x03\x02\x02\x02qi\x03\x02" +
		"\x02\x02qj\x03\x02\x02\x02qk\x03\x02\x02\x02ql\x03\x02\x02\x02qm\x03\x02" +
		"\x02\x02qn\x03\x02\x02\x02qo\x03\x02\x02\x02qp\x03\x02\x02\x02r\x17\x03" +
		"\x02\x02\x02\f\x1B!+2CNY_cq";
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!gdxParser.__ATN) {
			gdxParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(gdxParser._serializedATN));
		}

		return gdxParser.__ATN;
	}

}

export class FileContext extends ParserRuleContext {
	public node(): NodeContext[];
	public node(i: number): NodeContext;
	public node(i?: number): NodeContext | NodeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(NodeContext);
		} else {
			return this.getRuleContext(i, NodeContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_file; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterFile) {
			listener.enterFile(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitFile) {
			listener.exitFile(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitFile) {
			return visitor.visitFile(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NodeContext extends ParserRuleContext {
	public openBlock(): OpenBlockContext {
		return this.getRuleContext(0, OpenBlockContext);
	}
	public endBlock(): EndBlockContext {
		return this.getRuleContext(0, EndBlockContext);
	}
	public block(): BlockContext[];
	public block(i: number): BlockContext;
	public block(i?: number): BlockContext | BlockContext[] {
		if (i === undefined) {
			return this.getRuleContexts(BlockContext);
		} else {
			return this.getRuleContext(i, BlockContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_node; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterNode) {
			listener.enterNode(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitNode) {
			listener.exitNode(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitNode) {
			return visitor.visitNode(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class OpenBlockContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(gdxParser.ID, 0); }
	public attr(): AttrContext[];
	public attr(i: number): AttrContext;
	public attr(i?: number): AttrContext | AttrContext[] {
		if (i === undefined) {
			return this.getRuleContexts(AttrContext);
		} else {
			return this.getRuleContext(i, AttrContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_openBlock; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterOpenBlock) {
			listener.enterOpenBlock(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitOpenBlock) {
			listener.exitOpenBlock(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitOpenBlock) {
			return visitor.visitOpenBlock(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BlockContext extends ParserRuleContext {
	public node(): NodeContext | undefined {
		return this.tryGetRuleContext(0, NodeContext);
	}
	public value(): ValueContext | undefined {
		return this.tryGetRuleContext(0, ValueContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_block; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterBlock) {
			listener.enterBlock(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitBlock) {
			listener.exitBlock(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitBlock) {
			return visitor.visitBlock(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class EndBlockContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(gdxParser.ID, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_endBlock; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterEndBlock) {
			listener.enterEndBlock(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitEndBlock) {
			listener.exitEndBlock(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitEndBlock) {
			return visitor.visitEndBlock(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AttrContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(gdxParser.ID, 0); }
	public STRING_(): TerminalNode { return this.getToken(gdxParser.STRING_, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_attr; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterAttr) {
			listener.enterAttr(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitAttr) {
			listener.exitAttr(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitAttr) {
			return visitor.visitAttr(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class InstanceContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(gdxParser.ID, 0); }
	public value(): ValueContext[];
	public value(i: number): ValueContext;
	public value(i?: number): ValueContext | ValueContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ValueContext);
		} else {
			return this.getRuleContext(i, ValueContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_instance; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterInstance) {
			listener.enterInstance(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitInstance) {
			listener.exitInstance(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitInstance) {
			return visitor.visitInstance(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DictionaryContext extends ParserRuleContext {
	public pair(): PairContext[];
	public pair(i: number): PairContext;
	public pair(i?: number): PairContext | PairContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PairContext);
		} else {
			return this.getRuleContext(i, PairContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_dictionary; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterDictionary) {
			listener.enterDictionary(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitDictionary) {
			listener.exitDictionary(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitDictionary) {
			return visitor.visitDictionary(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PairContext extends ParserRuleContext {
	public STRING_(): TerminalNode | undefined { return this.tryGetToken(gdxParser.STRING_, 0); }
	public value(): ValueContext {
		return this.getRuleContext(0, ValueContext);
	}
	public ID(): TerminalNode | undefined { return this.tryGetToken(gdxParser.ID, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_pair; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterPair) {
			listener.enterPair(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitPair) {
			listener.exitPair(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitPair) {
			return visitor.visitPair(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ArrayContext extends ParserRuleContext {
	public value(): ValueContext[];
	public value(i: number): ValueContext;
	public value(i?: number): ValueContext | ValueContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ValueContext);
		} else {
			return this.getRuleContext(i, ValueContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_array; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterArray) {
			listener.enterArray(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitArray) {
			listener.exitArray(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitArray) {
			return visitor.visitArray(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ValueContext extends ParserRuleContext {
	public INT(): TerminalNode | undefined { return this.tryGetToken(gdxParser.INT, 0); }
	public FLOAT_(): TerminalNode | undefined { return this.tryGetToken(gdxParser.FLOAT_, 0); }
	public STRING_(): TerminalNode | undefined { return this.tryGetToken(gdxParser.STRING_, 0); }
	public dictionary(): DictionaryContext | undefined {
		return this.tryGetRuleContext(0, DictionaryContext);
	}
	public array(): ArrayContext | undefined {
		return this.tryGetRuleContext(0, ArrayContext);
	}
	public instance(): InstanceContext | undefined {
		return this.tryGetRuleContext(0, InstanceContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return gdxParser.RULE_value; }
	// @Override
	public enterRule(listener: gdxListener): void {
		if (listener.enterValue) {
			listener.enterValue(this);
		}
	}
	// @Override
	public exitRule(listener: gdxListener): void {
		if (listener.exitValue) {
			listener.exitValue(this);
		}
	}
	// @Override
	public accept<Result>(visitor: gdxVisitor<Result>): Result {
		if (visitor.visitValue) {
			return visitor.visitValue(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


